﻿#include <iostream>
#include <string>
#include <vector>
using namespace std;
//template<class T1,class T2>
//T1 add(T1 x, T2 y)
//{
//	return x + y;
//}
//
//
//int main()
//{
//	std::cout << add(1.1, 20);
//	return 0;
//}



//class Person
//{
//public:
//	void print()
//	{
//		std::cout << name << ";" << age << ";" << height << std::endl;
//	}
//protected:
//	std::string name = "张三";
//	int age = 18;
//	int height = 180;
//};
//
//class Student : public Person
//{
//public:
//	int studens;
//};
//
//class Teacher : public Person
//{
//public:
//	int jobnumber;
//};
//
//
//
//int main()
//{
//	Student s;
//	Teacher t;
//	s.print();
//	t.print();
//	
//	return 0;
//}

/*------------------- 通过继承对基类的成员进行使用 ------------------*/
//class base
//{
//public:
//	int _a = 1;
//	int _b = 2;
//	void print()
//	{
//		cout << _a << ";" << _b << endl;
//	}
//};
//
//class derived : public base
//{
//public:
//
//	void print()
//	{
//		_a = 10;
//		_b = 20;
//		cout << _a << ";" << _b << endl;
//	}
//};
//
//int main()
//{
//	base b;
//	b.print();
//
//	derived d;
//	d.print();
//
//	b.print();
//	return 0;
//}






/*---------- 继承类模板 ---------------------*/

//template<class T>
//class myclass : public std::vector<T>
//{
//public:
//	void push(const T& value)
//	{
//		/*------ 要点 -------
//		基类是模板时，必须指定类域 否则报错，找不到标识符 错误案例:psuh_back(value)
//		因为模板是按需实例化。
//		myclass 实例化时，vector也实例化
//		
//		--------------------*/
//		std::vector<T>::push_back(value);
//	}
//	void pop()
//	{
//		std::vector<T>::pop_back();
//	}
//
//	T top()
//	{
//		return std::vector<T>::back();
//	}
//
//	bool empty()
//	{
//		return std::vector<T>::empty();
//	}
//
//};
//
//
//int main()
//{
//	myclass<int> a;
//	a.push(1);
//	a.push(2);
//	a.push(3);
//	while (!a.empty())
//	{
//		std::cout << a.top() << std::endl;
//		a.pop();
//	}
//	return 0;
//}


/*-------------------- 派生类转基类  ------------------------*/
//class base
//{
//public:
//	int _a = 1;
//	int _b = 2;
//
//};
//	
//class derived : public base
//{
//public:
//	int _c;
//
//};
	
//int main()
//{
//	/*-------- 要点 ---------------
//	派生类可以赋值给基类的 (引用/指针)
//	就是把派生类中基类的部分切割出来  基类指针或引用指向的就是派生类切割出来基类的那一部分
//	派生类可以赋值给基类 但是 基类不可以赋值类派生类
//
//	-----------------------------*/
//
//	derived d;
//
//	//base* p = &d;
//	//p->_a = 11;
//	// 
//	//1.传指针或者引用，共用的是一块内存，通过指针或者引用修改变量 就是 修改 派生类的变量
//
//	base& bp = d;
//	bp._a = 11;
//
//	base* pb = &d;		
//	pb->_a = 10;
//	//2.这里 b d 不共用内存 b的修改不会影响d
//	base b = d;			
//	b._a = 100;
//
//}



/*----------- 继承中的作用域 -> 隐藏 -----------------*/
//class base
//{
//public:
//	int _a = 1;
//	int _b = 2;
//
//};
//	
//class derived : public base
//{
//public:
//	int _a = 10;
//	int _c = 3;
//
//	void print()
//	{
//		//这里的a访问的是 derived的a 如果想要访问base的a  -> base::a
//		//cout << _a 
//		//<< ";" << _b 
//		//<< ";" << _c << endl;
//		cout << _a << ";" << base::_a
//			<< ";" << _b
//			<< ";" << _c << endl;
//	}
//
//};
//
//int main()
//{
//	derived d;
//	d.print();
//
//	return 0;
//}


/*---------------- 派生类的默认成员函数 ------------------*/

//class base 
//{
//public:
//	base(const char* name):_name(name)
//	{
//		cout << "base()" << endl;
//	}
//	//拷贝构造
//	base(const base& b)
//	{
//		_name = b._name;
//		cout << "base(const base& b)" << endl;
//	}
//
//	//赋值重载
//	// 如果派生类想要调用基类的赋值重载记得要包含类域
//	//base& operator=(const base& b)
//	//{
//	//	if (this != &b)
//	//	{
//	//		_name = b._name;
//	//	}
//	//	return *this;
//	//}
//
//
//	//析构函数不需要显示调用，派生类析构完成之后会自动调用基类的析构
//	~base()
//	{
//		cout << "~base()" << endl;
//	}
//
//protected:
//	string _name;
//
//};
//
//class derived : public base
//{
//public:
//	//派生类的构造函数必须调用基类的构造函数来构造派生类的基类那一部分
//	//在构造时候 会先调用基类构造在调用派生类构造
//	derived(const char* name,int num)
//			:_num(num),
//			base(name)
//	{
//		
//		cout << "derived()" << endl;
//		
//	}
//
//	//derived(const derived& d)
//	//{
//
//	//}
//
//
//	//derived& operate=(const derived& d)
//	//{
//
//	//}
//
//	~derived()
//	{
//		cout << "~derived()" << endl;
//	}
//
//protected:
//	int _num;
//
//
//};


//int main()
//{
//	//base b("ls");
//	
//	derived d("ls",11);
//	//derived dd(d);
//	derived dd = d;	//调用拷贝构造
//	dd = d;			//调用赋值重载
//	return 0;
//}


/*---------------- 不能被继承的类 ------------------*/
//
//class base final
//{
//public:
//	string name;
//};
//
// 继承的时候时间报错无法继承
//class derived : public base
//{
//
//};

////////友元关系不能继承


/*---------------- 继承与静态成员 ------------------*/
//基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。
//无论派生出多少个派生类，都只有⼀个static成员实例
class base
{
public:
	int _a = 1;
	static int _b;	//静态成员不可以在这里初始化
};
int base::_b = 0;
class derived : public base
{
public:
	int _c = 3;
};

int main()
{
	base b;
	derived d;
	
	cout << &d._a << endl << &b._a << endl;	//a被继承下来的，但是共用的不是一块内存。说明是被继承下来了

	cout << &d._b << endl << &b._b << endl;	//这里基类和派生类的静态成员地址是一样的，说明是共用一份成员

	//公有情况下基类 派生类都可以访问
	cout << base::_b << endl << derived::_b << endl;
	return 0;
}